import request from '@/utils/request'
import { diagnoseTasks, checkDatabaseTasks } from '@/utils/debugTools'

// 获取任务列表
export async function getTaskList(params) {
  console.log('开始获取任务列表，参数:', params);
  
  // 记录用户信息用于调试
  try {
    const userStr = localStorage.getItem('user');
    if (userStr) {
      const user = JSON.parse(userStr);
      console.log('当前用户:', user.username, '类型:', user.type);
    }
  } catch (e) {
    console.warn('解析用户信息时出错:', e.message);
  }
  
  try {
    // 发起请求获取任务列表
    console.log('请求任务API...');
    const response = await request({
      url: '/api/tasks',
      method: 'get',
      params,
      // 添加超时设置
      timeout: 10000,
      // 记录请求和响应信息
      transformRequest: [function (data, headers) {
        console.log('请求头:', headers);
        return data;
      }]
    });
    
    console.log('任务API返回状态:', response.status);
    // 保存原始响应
    const originalResponse = response.data;
    console.log('原始响应数据:', originalResponse);
    
    // 检查响应中是否存在错误信息
    if (originalResponse && originalResponse.message && (
        originalResponse.message.includes('不存在') || 
        originalResponse.message.includes('Not Found') ||
        originalResponse.message.includes('失败') ||
        originalResponse.message.includes('错误'))) {
      console.warn('API返回错误信息:', originalResponse.message);
      return {
        success: false,
        code: originalResponse.code || 404,
        data: [],
        message: originalResponse.message,
        originalResponse
      };
    }
    
    // 检查响应是否为空
    if (!originalResponse) {
      console.warn('API返回空响应');
      return {
        success: false,
        code: 500,
        data: [],
        message: '服务器返回空响应',
        originalResponse
      };
    }
    
    // 检查响应是否是错误对象
    if (originalResponse.code && originalResponse.code !== 200 && originalResponse.code !== 0) {
      console.warn('API返回错误代码:', originalResponse.code);
      return {
        success: false,
        code: originalResponse.code,
        data: [],
        message: originalResponse.message || '服务器返回错误代码',
        originalResponse
      };
    }
    
    // 使用提取函数解析响应
    const taskList = extractTasksFromResponse(originalResponse);
    console.log('提取任务列表结果:', taskList ? `成功，共${taskList.length}条任务` : '失败');
    
    // 构造标准化响应
    return {
      success: true,
      code: 200,
      data: taskList,
      originalResponse
    };
  } catch (error) {
    console.error('获取任务列表失败:', error);
    
    // 详细记录错误信息
    if (error.response) {
      console.error('错误响应状态:', error.response.status);
      console.error('错误响应头:', error.response.headers);
      console.error('错误响应数据:', error.response.data);
    } else if (error.request) {
      console.error('请求已发送但没有收到响应');
      console.error('请求对象:', error.request);
    } else {
      console.error('设置请求时发生错误:', error.message);
    }
    console.error('错误配置:', error.config);
    
    // 获取错误详情
    let errorDetails = '请求失败';
    let statusCode = 500;
    
    if (error.response) {
      statusCode = error.response.status;
      errorDetails = `服务器错误 (${statusCode})`;
      
      // 尝试提取错误信息
      if (error.response.data) {
        if (typeof error.response.data === 'string') {
          errorDetails = error.response.data;
        } else if (error.response.data.message) {
          errorDetails = error.response.data.message;
        }
      }
    } else if (error.message) {
      errorDetails = error.message;
    }
    
    return {
      success: false,
      code: statusCode,
      message: errorDetails,
      data: [],
      error: error
    };
  }
}

/**
 * 从响应中提取任务列表
 * @param {Object|Array} response API响应
 * @returns {Array} 任务列表
 */
export function extractTasksFromResponse(response) {
  console.log('提取任务, 原始响应类型:', typeof response);
  
  // 处理null或undefined响应
  if (!response) {
    console.warn('响应为空');
    return [];
  }
  
  // 如果响应是字符串，尝试解析JSON
  if (typeof response === 'string') {
    try {
      console.log('尝试解析字符串响应为JSON');
      response = JSON.parse(response);
    } catch (e) {
      console.error('字符串响应解析失败:', e.message);
      return [];
    }
  }
  
  // 直接是数组的情况
  if (Array.isArray(response)) {
    console.log(`响应直接是数组，长度: ${response.length}`);
    return response;
  }
  
  // 标准响应格式: { data: [...] }
  if (response.data && Array.isArray(response.data)) {
    console.log(`标准响应格式 data 字段，长度: ${response.data.length}`);
    return response.data;
  }
  
  // 其他常见格式
  // 1. { list: [...] }
  if (response.list && Array.isArray(response.list)) {
    console.log(`响应包含 list 字段，长度: ${response.list.length}`);
    return response.list;
  }
  
  // 2. { content: [...] }
  if (response.content && Array.isArray(response.content)) {
    console.log(`响应包含 content 字段，长度: ${response.content.length}`);
    return response.content;
  }
  
  // 3. { tasks: [...] }
  if (response.tasks && Array.isArray(response.tasks)) {
    console.log(`响应包含 tasks 字段，长度: ${response.tasks.length}`);
    return response.tasks;
  }
  
  // 4. { records: [...] }
  if (response.records && Array.isArray(response.records)) {
    console.log(`响应包含 records 字段，长度: ${response.records.length}`);
    return response.records;
  }
  
  // 5. { items: [...] }
  if (response.items && Array.isArray(response.items)) {
    console.log(`响应包含 items 字段，长度: ${response.items.length}`);
    return response.items;
  }
  
  // 嵌套格式: { data: { list: [...] } }
  if (response.data && typeof response.data === 'object') {
    // { data: { list: [...] } }
    if (response.data.list && Array.isArray(response.data.list)) {
      console.log(`嵌套响应 data.list，长度: ${response.data.list.length}`);
      return response.data.list;
    }
    
    // { data: { content: [...] } }
    if (response.data.content && Array.isArray(response.data.content)) {
      console.log(`嵌套响应 data.content，长度: ${response.data.content.length}`);
      return response.data.content;
    }
    
    // { data: { tasks: [...] } }
    if (response.data.tasks && Array.isArray(response.data.tasks)) {
      console.log(`嵌套响应 data.tasks，长度: ${response.data.tasks.length}`);
      return response.data.tasks;
    }
    
    // { data: { records: [...] } }
    if (response.data.records && Array.isArray(response.data.records)) {
      console.log(`嵌套响应 data.records，长度: ${response.data.records.length}`);
      return response.data.records;
    }
    
    // { data: { items: [...] } }
    if (response.data.items && Array.isArray(response.data.items)) {
      console.log(`嵌套响应 data.items，长度: ${response.data.items.length}`);
      return response.data.items;
    }
  }
  
  // 检查所有属性，寻找任何数组类型的字段
  console.log('尝试查找任何数组类型字段...');
  const keys = Object.keys(response);
  for (const key of keys) {
    if (Array.isArray(response[key])) {
      console.log(`找到数组字段 "${key}"，长度: ${response[key].length}`);
      return response[key];
    }
    
    // 检查二级嵌套
    if (response[key] && typeof response[key] === 'object') {
      const nestedKeys = Object.keys(response[key]);
      for (const nestedKey of nestedKeys) {
        if (Array.isArray(response[key][nestedKey])) {
          console.log(`找到嵌套数组字段 "${key}.${nestedKey}"，长度: ${response[key][nestedKey].length}`);
          return response[key][nestedKey];
        }
      }
    }
  }
  
  // 检查响应是否包含错误信息
  if (response.message && (
      response.message.includes('不存在') || 
      response.message.includes('Not Found'))) {
    console.warn(`响应中包含错误信息: ${response.message}`);
    return [];
  }
  
  console.warn('无法在响应中找到任务列表数组，响应结构:', Object.keys(response).join(', '));
  return [];
}

// 获取任务详情
export function getTaskDetail(taskId) {
  console.log('开始获取任务详情，ID:', taskId);
  
  return request({
    url: `/api/tasks/${taskId}`,
    method: 'get',
    timeout: 10000,
    transformResponse: [function(data) {
      if (!data) {
        console.log('获取任务详情：服务器返回空响应');
        return { success: false, message: '服务器返回空响应' };
      }
      
      try {
        // 只有当数据是字符串且不为空时才尝试解析JSON
        if (typeof data === 'string' && data.trim()) {
          console.log('获取任务详情：收到字符串响应，长度:', data.length);
          return JSON.parse(data);
        }
        
        // 如果已经是对象，直接返回
        if (typeof data === 'object') {
          console.log('获取任务详情：收到对象响应');
          return data;
        }
        
        return { data: data };
      } catch (e) {
        console.error('获取任务详情：解析响应数据失败:', e.message);
        return { 
          success: false,
          message: '响应数据解析失败',
          originalData: typeof data === 'string' ? data.substring(0, 200) : '无法显示'
        };
      }
    }]
  }).then(response => {
    console.log('获取任务详情成功，响应:', response);
    return response;
  }).catch(error => {
    console.error('获取任务详情失败:', error);
    
    // 提供详细错误信息
    let errorMsg = '获取任务详情失败';
    
    if (error.response) {
      const status = error.response.status;
      errorMsg = `服务器返回错误 (${status}): `;
      
      if (error.response.data) {
        if (typeof error.response.data === 'string') {
          errorMsg += error.response.data;
        } else if (error.response.data.message) {
          errorMsg += error.response.data.message;
        } else if (error.response.data.error) {
          errorMsg += error.response.data.error;
        }
      }
      
      if (status === 404) {
        errorMsg = '任务不存在或已被删除';
      }
    } else if (error.request) {
      errorMsg = '服务器无响应，请检查网络连接';
      
      if (error.code === 'ECONNABORTED') {
        errorMsg = '请求超时，服务器可能繁忙';
      }
    } else {
      errorMsg = error.message || '请求配置错误';
    }
    
    return Promise.reject(new Error(errorMsg));
  });
}

// 创建任务
export function createTask(data) {
  // 检查token是否存在
  const token = localStorage.getItem('token');
  if (!token) {
    console.error('创建任务失败：未检测到登录令牌');
    return Promise.reject(new Error('请先登录'));
  }

  // 检查用户类型
  const userType = localStorage.getItem('userType');
  if (userType !== 'company') {
    console.error('创建任务失败：非企业用户无法创建任务');
    return Promise.reject(new Error('只有企业用户才能发布任务'));
  }
  
  // 尝试检查token是否有效
  try {
    // 检查token基本结构
    const tokenParts = token.split('.');
    if (tokenParts.length !== 3) {
      console.error('创建任务失败：令牌格式不正确');
      return Promise.reject(new Error('登录令牌格式错误，请重新登录'));
    }
    
    // 尝试解码payload
    try {
      const payload = JSON.parse(atob(tokenParts[1]));
      // 检查过期时间
      if (payload.exp && payload.exp * 1000 < Date.now()) {
        console.error('创建任务失败：令牌已过期', payload.exp);
        return Promise.reject(new Error('登录状态已过期，请重新登录'));
      }
      // 检查userType
      if (payload.userType !== 'company') {
        console.error('令牌中的用户类型与当前不匹配', payload.userType, userType);
        return Promise.reject(new Error('令牌中的用户类型无效，请重新登录'));
      }
      console.log('Token有效，Payload:', {
        exp: new Date(payload.exp * 1000).toLocaleString(),
        userType: payload.userType
      });
    } catch (e) {
      console.error('解析令牌出错:', e);
      // 不直接返回错误，继续让请求发出去
    }
  } catch (e) {
    console.error('处理令牌时出错:', e);
  }

  console.log('正在发送创建任务请求，数据:', Object.keys(data));
  console.log('Authorization: Bearer ' + (token ? token.substring(0, 10) + '...' : 'null'));
  console.log('用户类型:', userType);
  
  // 检查token格式是否正确
  if (token && !token.trim()) {
    console.error('创建任务失败：令牌格式不正确');
    return Promise.reject(new Error('登录令牌格式错误，请重新登录'));
  }
  
  // 增加超时和重试配置
  const requestConfig = {
    url: '/api/tasks',
    method: 'post',
    headers: {
      'Accept': 'application/json',
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + token.trim() // 确保直接在这里设置，避免被覆盖
    },
    data,
    timeout: 30000, // 增加超时时间到30秒
    // 添加请求拦截器，记录详细信息
    transformRequest: [function (data, headers) {
      console.log('准备发送数据:', data);
      console.log('请求头:', headers);
      return JSON.stringify(data);
    }],
    // 添加响应拦截器，尝试处理各种响应格式
    transformResponse: [function (data) {
      console.log('收到原始响应类型:', typeof data);
      if (data === null || data === undefined) {
        console.log('收到空响应');
        return { success: true, message: '请求已处理，但服务器未返回数据' };
      }
      
      try {
        // 只有当数据是字符串且不为空时才尝试解析JSON
        if (typeof data === 'string' && data.trim()) {
          console.log('收到字符串响应，长度:', data.length);
          console.log('响应示例:', data.length > 100 ? data.substring(0, 100) + '...' : data);
          return JSON.parse(data);
        }
        
        // 如果已经是对象，直接返回
        if (typeof data === 'object') {
          console.log('收到对象响应，键:', Object.keys(data || {}));
          return data;
        }
        
        console.log('收到其他类型响应:', data);
        return { data: data };
      } catch (e) {
        console.error('解析响应数据失败:', e);
        return { 
          parseError: true, 
          originalData: typeof data === 'string' ? data.substring(0, 200) : '无法显示',
          message: '响应数据解析失败'
        };
      }
    }]
  };
  
  return request(requestConfig).then(response => {
    console.log('创建任务成功，响应:', response);
    
    // 处理各种响应格式
    if (response.parseError) {
      console.warn('响应格式异常，但请求可能已成功');
      // 返回一个标准结构，让后续处理能够继续
      return {
        success: true,
        data: true,
        message: '请求已发送，但无法确认结果，请检查任务列表'
      };
    }
    
    // 处理Spring Boot常见的响应格式
    if (response.code !== undefined) {
      if (response.code === 200 || response.code === 0) {
        return {
          success: true,
          data: response.data || true
        };
      } else {
        throw new Error(response.message || '创建任务失败');
      }
    }
    
    return response;
  }).catch(error => {
    console.error('创建任务失败:', error);
    // 提供详细错误信息
    let errorMsg = '创建任务失败';
    
    if (error.response) {
      console.error('错误状态码:', error.response.status);
      console.error('错误数据:', error.response.data);
      
      if (error.response.status === 401) {
        errorMsg = '认证失败：' + (error.response.data?.message || '登录令牌已过期，请重新登录');
        // 如果是token过期，提供明确的提示
        if (error.response.data?.message && error.response.data.message.includes('过期')) {
          errorMsg = '登录状态已过期，请重新登录';
        }
      } else if (error.response.status === 403) {
        errorMsg = '权限不足：' + (error.response.data?.message || '只有企业用户才能发布任务');
      } else {
        errorMsg = error.response.data?.error || 
                  error.response.data?.message || 
                  '服务器错误，请稍后重试';
      }
    } else if (error.request) {
      // 请求已发送但未收到响应
      console.error('请求已发送但未收到响应:', error.request);
      errorMsg = '服务器无响应，请检查网络连接';
      
      // 检查是否是超时
      if (error.code === 'ECONNABORTED') {
        errorMsg = '请求超时，服务器可能繁忙';
      }
    } else {
      // 请求设置有问题
      errorMsg = error.message || '请求配置错误';
    }
    
    return Promise.reject(new Error(errorMsg));
  });
}

// 撤销任务
export function cancelTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/cancel`,
    method: 'post'
  })
}

// 申请任务
export function applyTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/apply`,
    method: 'post'
  })
}

// 取消申请任务
export function cancelApplyTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/cancel-apply`,
    method: 'post'
  })
}

// 接受申请
export function acceptApplication(applicationId) {
  return request({
    url: `/api/tasks/applications/${applicationId}/accept`,
    method: 'post'
  })
}

// 拒绝申请
export function rejectApplication(applicationId) {
  return request({
    url: `/api/tasks/applications/${applicationId}/reject`,
    method: 'post'
  })
}

// 完成任务
export function completeTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/complete`,
    method: 'post'
  })
}

// 终止任务
export function terminateTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/terminate`,
    method: 'post'
  })
}

// 获取任务统计数据
export async function getTaskStatistics() {
  try {
    const response = await request({
      url: '/api/task-analysis/statistics',
      method: 'get'
    });
    return response;
  } catch (error) {
    console.error('获取任务统计数据失败:', error);
    throw error;
  }
}

// 获取任务状态分布
export async function getTaskStatusDistribution() {
  try {
    const response = await request({
      url: '/api/task-analysis/status-distribution',
      method: 'get'
    });
    return response;
  } catch (error) {
    console.error('获取任务状态分布失败:', error);
    throw error;
  }
}

// 获取任务类型分布
export async function getTaskTypeDistribution() {
  try {
    const response = await request({
      url: '/api/task-analysis/type-distribution',
      method: 'get'
    });
    return response;
  } catch (error) {
    console.error('获取任务类型分布失败:', error);
    throw error;
  }
}

// 获取任务薪资趋势
export async function getTaskSalaryTrend(params) {
  try {
    const response = await request({
      url: '/api/task-analysis/salary-trend',
      method: 'get',
      params
    });
    return response;
  } catch (error) {
    console.error('获取任务薪资趋势失败:', error);
    throw error;
  }
}

// 获取任务完成率统计
export async function getTaskCompletionStats(params) {
  try {
    const response = await request({
      url: '/api/task-analysis/completion-stats',
      method: 'get',
      params
    });
    return response;
  } catch (error) {
    console.error('获取任务完成率统计失败:', error);
    throw error;
  }
}

// 获取任务地区分布
export async function getTaskLocationDistribution() {
  try {
    const response = await request({
      url: '/api/task-analysis/location-distribution',
      method: 'get'
    });
    return response;
  } catch (error) {
    console.error('获取任务地区分布失败:', error);
    throw error;
  }
}

// 零工标记任务为已完成
export function workerCompleteTask(taskId) {
  return request({
    url: `/api/tasks/${taskId}/worker-complete`,
    method: 'post'
  })
} 